home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume2 / unix / shell211.2 < prev    next >
Text File  |  1988-10-25  |  34KB  |  1,670 lines
  1. Path: xanth!nic.MR.NET!tank!ncar!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v02i023:  shell - cshell-like command processor V2.11, Part02/02
  5. Message-ID: <9831@swan.ulowell.edu>
  6. Date: 25 Oct 88 01:47:41 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 1659
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: dillon@cory.berkeley.edu (Matt Dillon)
  12. Posting-number: Volume 2, Issue 23
  13. Archive-name: unix/shell211.2
  14.  
  15. # This is a shell archive.  Remove anything before this line
  16. # then unpack it by saving it in a file and typing "sh file"
  17. # (Files unpacked will be owned by you and have default permissions).
  18. # This archive contains the following files:
  19. #    Makefile
  20. #    TODO
  21. #    c.asm
  22. #    comm1.c
  23. #    comm2.c
  24. #
  25. if `test ! -s Makefile`
  26. then
  27. echo "writing Makefile"
  28. cat > Makefile << '\Rogue\Monster\'
  29.  
  30. #  SHELL makefile for AZTEC C
  31.  
  32. EXE  = srcc:shell
  33. SYMS = ram:symbols.m
  34. SYM  = comp:include/symbols.m
  35.  
  36. AUX  = $(EXE) TODO examples.txt shell.h
  37.  
  38. SRC1 = execom.c
  39. SRC2 = comm2.c
  40. SRC3 = set.c
  41. SRC4 = sub.c
  42. SRC5 = main.c
  43. SRC6 = globals.c
  44. SRC7 = comm1.c
  45. SRC8 = run.c
  46. SRC9 = fexec1.c
  47. SRCA = fexec2.asm
  48. SRCB = c.asm
  49. SRCC = sort.c
  50. SRCD = hat.c
  51.  
  52. OBJ1 = vd0:execom.o
  53. OBJ2 = vd0:comm2.o
  54. OBJ3 = vd0:set.o
  55. OBJ4 = vd0:sub.o
  56. OBJ5 = vd0:main.o
  57. OBJ6 = vd0:globals.o
  58. OBJ7 = vd0:comm1.o
  59. OBJ8 = vd0:run.o
  60. OBJ9 = vd0:fexec1.o
  61. OBJA = vd0:fexec2.o
  62. OBJB = vd0:c.o
  63. OBJC = vd0:sort.o
  64. OBJD = vd0:hat.o
  65.  
  66. SRCS = $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8) $(SRC9) $(SRCA) $(SRCB) $(SRCC) $(SRCD)
  67.  
  68. OBJS = $(OBJ1) $(OBJ2) $(OBJ3) $(OBJ4) $(OBJ5) $(OBJ6) $(OBJ7) $(OBJ8) $(OBJ9) $(OBJA) $(OBJB) $(OBJC) $(OBJD)
  69.  
  70. CFLAGS    = +L +I$(SYMS)
  71.  
  72.  
  73. $(EXE): $(SYMS) $(OBJS)
  74.     ln +Q $(OBJS) -lsup32 -ldres -lc32 -o $(EXE)
  75.  
  76. arc:
  77.     -delete ram:shell.arc
  78.     arc a ram:shell $(SRCS)
  79.     arc a ram:shell $(AUX)
  80.  
  81.  
  82. $(SYMS):    $(SYM)
  83.     copy $(SYM) $(SYMS)
  84.  
  85. $(OBJ1): $(SRC1)
  86.     cc $(CFLAGS) $*.c -o $(OBJ1)
  87. $(OBJ2): $(SRC2)
  88.     cc $(CFLAGS) $*.c -o $(OBJ2)
  89. $(OBJ3): $(SRC3)
  90.     cc $(CFLAGS) $*.c -o $(OBJ3)
  91. $(OBJ4): $(SRC4)
  92.     cc $(CFLAGS) $*.c -o $(OBJ4)
  93. $(OBJ5): $(SRC5)
  94.     cc $(CFLAGS) $*.c -o $(OBJ5)
  95. $(OBJ6): $(SRC6)
  96.     cc $(CFLAGS) $*.c -o $(OBJ6)
  97. $(OBJ7): $(SRC7)
  98.     cc $(CFLAGS) $*.c -o $(OBJ7)
  99. $(OBJ8): $(SRC8)
  100.     cc $(CFLAGS) $*.c -o $(OBJ8)
  101. $(OBJ9): $(SRC9)
  102.     cc $(CFLAGS) $*.c -o $(OBJ9)
  103. $(OBJA): $(SRCA)
  104.     as $*.asm -o     $(OBJA)
  105. $(OBJB): $(SRCB)
  106.     as $*.asm -o     $(OBJB)
  107. $(OBJC): $(SRCC)
  108.     cc $(CFLAGS) $*.c -o $(OBJC)
  109. $(OBJD): $(SRCD)
  110.     cc $(CFLAGS) $*.c -o $(OBJD)
  111.  
  112.  
  113. \Rogue\Monster\
  114. else
  115.   echo "will not over write Makefile"
  116. fi
  117. if [ `wc -c Makefile | awk '{printf $1}'` -ne 1665 ]
  118. then
  119. echo `wc -c Makefile | awk '{print "Got " $1 ", Expected " 1665}'`
  120. fi
  121. if `test ! -s TODO`
  122. then
  123. echo "writing TODO"
  124. cat > TODO << '\Rogue\Monster\'
  125.  
  126.     -SetFileDate() routine in comm2.c
  127.  
  128.     -set xx " x"  initial space ignored in quoted section.
  129.     -change -f to -e
  130.  
  131.  
  132.     -version
  133.  
  134.     -history rel.
  135.  
  136.     -flag copy noisy.
  137.  
  138.  
  139.  
  140. recompile version
  141.  
  142. LATTICE free_memory().
  143.  
  144. PIPE/PARALLEL implimentation:
  145.  
  146.     a | b    -pipe
  147.     a || b    -execute in parallel parallel
  148.  
  149. break each command into:
  150.  
  151.     command, parameters
  152.     input redirection or pipe in
  153.     output redirection or pipe out
  154.  
  155.     call command executor
  156.  
  157.  
  158. MUST always specify redirection file names.
  159.  
  160. command executor:
  161.     If not pipe segment (last seg is not considered a pipe)
  162.     execute via shell
  163.     else
  164.     execute a RUN via shell
  165.     send pipe terminate command for input and output pipe's in case RUN
  166.     failed.
  167.  
  168.  
  169. external(avlist, infilename, outfilename)
  170. char **avlist;
  171. char *infilename;   NULL means take last pipe segment
  172. char *outfilename;  NULL means send to next pipe segment
  173. {
  174.     figure out aux. names (for pipes).
  175.     if (outfilename == NULL) {
  176.     exec a c:RUN >file <file
  177.     if (infilename == NULL)     /* Ensure pipe has been cleared */
  178.         pipeclear inpipe
  179.     if (outfilename == NULL)
  180.         pipeclear outpipe
  181.     } else {
  182.     open pert. files
  183.     exec a .........
  184.     close pert. files
  185.     }
  186. }
  187.  
  188.  
  189. \Rogue\Monster\
  190. else
  191.   echo "will not over write TODO"
  192. fi
  193. if [ `wc -c TODO | awk '{printf $1}'` -ne 1200 ]
  194. then
  195. echo `wc -c TODO | awk '{print "Got " $1 ", Expected " 1200}'`
  196. fi
  197. if `test ! -s c.asm`
  198. then
  199. echo "writing c.asm"
  200. cat > c.asm << '\Rogue\Monster\'
  201. ;:ts=8
  202. ; Copyright (C) 1986,1987 by Manx Software Systems, Inc.
  203. ;
  204. ;       Initial startup routine for Aztec C.
  205. ;       NOTE: code down to "start" must be placed at beginning of
  206. ;               all programs linked with Aztec Linker using small
  207. ;               code or small data.
  208.  
  209.         mc68881
  210.         entry   .begin
  211.         public  .begin
  212.  
  213.         FAR code
  214.         FAR data
  215.  
  216. .begin
  217.         move.l  a0,-(sp)
  218.         lea     _SysRegs,a0
  219.         movem.l d0-d7/a0-a6,(a0)
  220.         move.l  (sp)+,a0
  221.         bsr     _geta4                  ;get A4
  222.         lea     __H1_end,a1
  223.         lea     __H2_org,a2
  224.         cmp.l   a1,a2                   ;check if BSS and DATA together
  225.         bne     start                   ;no, don't have to clear
  226.         move.w  #((__H2_end-__H2_org)/4)-1,d1
  227.         bmi     start                   ;skip if no bss
  228.         move.l  #0,d2
  229. loop
  230.         move.l  d2,(a1)+                ;clear out memory
  231.         dbra    d1,loop
  232.  
  233. start
  234.         move.l  sp,__savsp              ;save stack pointer
  235.         move.l  4,a6                    ;get Exec's library base pointer
  236.         move.l  a6,_SysBase             ;put where we can get it
  237.         movem.l d0/a0,-(sp)             ;save CLI command parameters
  238.  
  239.         btst.b  #4,$129(a6)             ;check for 68881 flag in AttnFlags
  240.         beq     x1                      ;skip if not
  241.         lea     x2,a5
  242.         jsr     -30(a6)                 ;do it in supervisor mode
  243.         bra     x1
  244. x2
  245.         clr.l   -(sp)
  246.         frestore (sp)+                  ;reset the ffp stuff
  247.         rte                             ;and return
  248. x1
  249.  
  250.         lea     dos_name,a1             ;get name of dos library
  251.         jsr     -408(a6)                ;open the library any version
  252.         move.l  d0,_DOSBase             ;set it up
  253.         bne     x3                      ;skip if okay
  254.  
  255.         move.l  #$38007,d7              ;AG_OpenLib | AO_DOSLib
  256.         jsr     -108(a6)                ;Alert
  257.         bra     x4
  258. x3
  259.         jsr     __main                  ;call the startup stuff
  260. x4
  261.         add.w   #8,sp                   ;pop args
  262.         rts                             ;and return
  263.  
  264. dos_name:
  265.         dc.b    'dos.library',0
  266.  
  267.         public  _geta4
  268.  
  269. _geta4:
  270.         far     data
  271.         lea     __H1_org+32766,a4
  272.         rts
  273.  
  274.         public  __main,__H0_org
  275.  
  276.         dseg
  277.  
  278.         public  _SysRegs
  279.         public  _SysBase,__savsp,_DOSBase
  280.         public  __H1_org,__H1_end,__H2_org,__H2_end
  281.  
  282.  
  283.  
  284. \Rogue\Monster\
  285. else
  286.   echo "will not over write c.asm"
  287. fi
  288. if [ `wc -c c.asm | awk '{printf $1}'` -ne 2456 ]
  289. then
  290. echo `wc -c c.asm | awk '{print "Got " $1 ", Expected " 2456}'`
  291. fi
  292. if `test ! -s comm1.c`
  293. then
  294. echo "writing comm1.c"
  295. cat > comm1.c << '\Rogue\Monster\'
  296.  
  297. /*
  298.  * COMM1.C
  299.  *
  300.  * (c)1986 Matthew Dillon     9 October 1986
  301.  *
  302.  *    SLEEP
  303.  *    NUMBER      -handles values as commands, actually a NULL command.
  304.  *    CAT
  305.  *    COMMENT
  306.  *    DIR      -also handles DEVINFO
  307.  *    QUIT      -also handles EXIT
  308.  *    ECHO
  309.  *    SOURCE
  310.  *    CD
  311.  *    MKDIR
  312.  *    MV
  313.  *    RM
  314.  *    HISTORY
  315.  *    MEM
  316.  *    FOREACH
  317.  *    FOREVER
  318.  *
  319.  *    NOTE: SET/UNSET/ALIAS/UNALIAS handled in SET.C
  320.  *
  321.  */
  322.  
  323. #include "shell.h"
  324. #include <stdio.h>
  325.  
  326. extern LOCK *CreateDir(), *CurrentDir(), *ParentDir();
  327. extern LOCK *Lock(), *DupLock();
  328.  
  329. extern long disp_entry();
  330.  
  331. struct FileLock *Clock;
  332.  
  333. do_sleep()
  334. {
  335.     register int i;
  336.  
  337.     if (ac == 2) {
  338.     i = atoi(av[1]);
  339.     while (i > 0) {
  340.         Delay (50*2);
  341.         i -= 2;
  342.         if (CHECKBREAK())
  343.         break;
  344.      }
  345.     }
  346.     return (0);
  347. }
  348.  
  349.  
  350. do_number()
  351. {
  352.     return (0);
  353. }
  354.  
  355. do_cat()
  356. {
  357.     FILE *fi;
  358.     short i;
  359.     char buf[256];
  360.  
  361.     if (ac == 1) {
  362.     while (fgets(buf, 256, stdin)) {
  363.         Write(Cout, buf, strlen(buf));
  364.         if (CHECKBREAK())
  365.         break;
  366.     }
  367.     clearerr(stdin);
  368.     }
  369.     for (i = 1; i < ac; ++i) {
  370.     if (fi = fopen (av[i], "r")) {
  371.         while (fgets (buf, 256, fi)) {
  372.         Write(Cout, buf, strlen(buf));
  373.         if (CHECKBREAK())
  374.             break;
  375.         }
  376.         fclose(fi);
  377.     } else {
  378.         fhprintf (Cerr, "could not open %s\n", av[i]);
  379.     }
  380.     }
  381.     return (0);
  382. }
  383.  
  384. /*
  385.  * comment file string
  386.  */
  387.  
  388. do_comment(str)
  389. char *str;
  390. {
  391.     register char *ptr = next_word(next_word(str));
  392.  
  393.     if (SetComment(av[1], ptr) == 0) {
  394.     perror(av[1]);
  395.     return(1);
  396.     }
  397.     return(0);
  398. }
  399.  
  400. do_dir(garbage, com)
  401. char *garbage;
  402. {
  403.     register struct DPTR      *dp;
  404.     register struct InfoData      *info;
  405.     char *name;
  406.     char br = 0;
  407.     register short i;
  408.     int   stat;
  409.     short longmode = 1;
  410.     short dcomment = 1;
  411.     short avstart = 1;
  412.     register long total = 0;
  413.  
  414.     if (av[1][0] == '-') {
  415.     ++avstart;
  416.     for (i = 1; av[1][i]; ++i) {
  417.         switch(av[1][i]) {
  418.         case 's':
  419.         longmode = 0;
  420.         break;
  421.         case 'l':
  422.         longmode = 1;
  423.         break;
  424.         case 'C':
  425.         dcomment = 0;
  426.         break;
  427.         }
  428.     }
  429.     }
  430.     if (ac == avstart)
  431.     av[ac++] = "";
  432.     for (i = avstart; !br && i < ac; ++i) {
  433.     if ((dp = dopen (av[i], &stat)) == NULL)
  434.         continue;
  435.     if (com < 0) {
  436.         info = (struct InfoData *)AllocMem(sizeof(struct InfoData), MEMF_PUBLIC);
  437.         if (Info (dp->lock, info)) {
  438.         int bpb = info->id_BytesPerBlock;
  439.         fhprintf (Cout, "Unit:%2ld  Errs:%3ld  Bytes: %-7ld Free: %-7ld %%full: %ld\n",
  440.                info->id_UnitNumber,
  441.                info->id_NumSoftErrors,
  442.                bpb * info->id_NumBlocks,
  443.                bpb * (info->id_NumBlocks - info->id_NumBlocksUsed),
  444.                info->id_NumBlocksUsed * 100 / info->id_NumBlocks
  445.         );
  446.         } else {
  447.         perror (av[i]);
  448.         }
  449.         FreeMem (info, sizeof(*info));
  450.     } else {
  451.         if (stat) {
  452.         while (dnext (dp, &name, &stat)) {
  453.             total += disp_entry (dp->fib, longmode, dcomment);
  454.             if (CHECKBREAK()) {
  455.             br = 1;
  456.             break;
  457.             }
  458.         }
  459.         } else {
  460.         total += disp_entry(dp->fib, longmode, dcomment);
  461.         }
  462.     }
  463.     dclose (dp);
  464.     }
  465.     fhprintf (Cout, "TOTAL: %ld\n", total);
  466.     return (0);
  467. }
  468.  
  469. static long
  470. disp_entry(fib, lengthy, comment)
  471. register struct FileInfoBlock *fib;
  472. {
  473.     char str[6];
  474.     char dstr[32];
  475.     register char *dirstr;
  476.  
  477.     str[5] = '\0';
  478.     str[0] = (fib->fib_Protection & FIBF_READ) ? '-' : 'r';
  479.     str[1] = (fib->fib_Protection & FIBF_WRITE) ? '-' : 'w';
  480.     str[2] = (fib->fib_Protection & FIBF_EXECUTE) ? '-' : 'x';
  481.     str[3] = (fib->fib_Protection & FIBF_DELETE) ? '-' : 'd';
  482.     str[4] = (fib->fib_Protection & FIBF_ARCHIVE) ? '-' : 'a';
  483.     dirstr = (fib->fib_DirEntryType < 0) ? "   " : "DIR";
  484.  
  485.     fhprintf (Cout, "%s %6ld %s  %-20s", str, (long)fib->fib_Size,
  486.     dirstr, fib->fib_FileName
  487.     );
  488.     if (lengthy)
  489.     fhprintf (Cout, " %s", datetos(&fib->fib_Date, dstr, "D M Y h:m"));
  490.     if (comment)
  491.     fhprintf (Cout, " %s", fib->fib_Comment);
  492.     fhprintf(Cout, "\n");
  493.     return ((long)fib->fib_Size);
  494. }
  495.  
  496.  
  497. do_quit()
  498. {
  499.     if (Src_stack) {
  500.     Quit = 1;
  501.     return(do_return());
  502.     }
  503.     main_exit (0);
  504. }
  505.  
  506.  
  507. do_echo(str)
  508. char *str;
  509. {
  510.     register char *ptr;
  511.     char nl = 1;
  512.  
  513.     for (ptr = str; *ptr && *ptr != ' '; ++ptr);
  514.     if (*ptr == ' ')
  515.     ++ptr;
  516.     if (av[1] && strcmp (av[1], "-n") == 0) {
  517.     nl = 0;
  518.     ptr += 2;
  519.     if (*ptr == ' ')
  520.         ++ptr;
  521.      }
  522.      Write(Cout, ptr, strlen(ptr));
  523.      if (nl)
  524.      Oputs("");
  525.      return (0);
  526. }
  527.  
  528.  
  529. do_source(str)
  530. char *str;
  531. {
  532.     register FILE *fi;
  533.     register char *buf;
  534.  
  535.     buf = malloc(256);
  536.     if (buf == NULL) {
  537.     Eputs ("no memory");
  538.     goto error;
  539.     }
  540.     if (Src_stack == MAXSRC) {
  541.     Eputs ("Too many source levels");
  542. error:
  543.     if ((long)av[0] == -1)
  544.         UnLock(av[1]);
  545.     return(-1);
  546.     }
  547.     if ((long)av[0] == -1) {
  548.     long oldir = (long)CurrentDir(av[1]);
  549.     fi = fopen("", "r");
  550.     UnLock(CurrentDir(oldir));
  551.     } else {
  552.     fi = fopen (av[1], "r");
  553.     }
  554.     if (fi == NULL) {
  555.     fhprintf(Cerr, "Cannot open %s\n", next_word(str));
  556.     return(-1);
  557.     }
  558.     set_var(LEVEL_SET, V_PASSED, next_word(next_word(str)));
  559.     ++H_stack;
  560.     Src_pos[Src_stack] = 0;
  561.     Src_base[Src_stack] = (long)fi;
  562.     ++Src_stack;
  563.     while (fgets(buf, 256, fi)) {
  564.     register int len = strlen(buf);
  565.     buf[len-1] = 0;             /* remove \n        */
  566.     Src_pos[Src_stack - 1] += len;        /* + (1 + actual length)    */
  567.     if (Verbose)
  568.         Eputs(buf);
  569.     exec_command (buf);
  570.     if (CHECKBREAK())
  571.         break;
  572.     }
  573.     --H_stack;
  574.     --Src_stack;
  575.     unset_level(LEVEL_LABEL + Src_stack);
  576.     unset_var(LEVEL_SET, V_PASSED);
  577.     fclose (fi);
  578.     return (0);
  579. }
  580.  
  581. /*
  582.  * CD
  583.  *
  584.  * CD(str, -1)      -do pwd and display current cd. if str = NULL don't disp.
  585.  * CD(str, 0)       -do CD operation.
  586.  *
  587.  *    standard operation: breakup path by '/'s and process independantly
  588.  *    x:    -reset cwd base
  589.  *    ..    -remove last cwd element
  590.  *    N     -add N or /N to cwd
  591.  */
  592.  
  593. do_cd(str, com)
  594. register char *str;
  595. {
  596.     static char cwd[256];
  597.     register char sc, *ptr;
  598.     char *name;
  599.  
  600.     if (com < 0) {
  601.     register struct FileLock *lock, *newlock;
  602.     register FIB *fib;
  603.     short i, len;
  604.  
  605.     fib = (FIB *)AllocMem(sizeof(FIB), 0);
  606.     Clock = (struct FileLock *)((PROC *)FindTask(0))->pr_CurrentDir;
  607.     if (!Clock)
  608.         CurrentDir(Clock = Lock(":", ACCESS_READ));
  609.     lock = DupLock(Clock);
  610.     cwd[i = 255] = '\0';
  611.     while (lock) {
  612.         newlock = ParentDir(lock);
  613.         Examine(lock, fib);
  614.         name = fib->fib_FileName;
  615.         if (*name == '\0')            /* HACK TO FIX RAM: DISK BUG */
  616.         name = "ram";
  617.         len = strlen(name);
  618.         if (newlock) {
  619.         if (i == 255) {
  620.             i -= len;
  621.             bmov(name, cwd + i, len);
  622.         } else {
  623.             i -= len + 1;
  624.             bmov(name, cwd + i, len);
  625.             cwd[i+len] = '/';
  626.         }
  627.         } else {
  628.         i -= len + 1;
  629.         bmov(name, cwd + i, len);
  630.         cwd[i+len] = ':';
  631.         }
  632.         UnLock(lock);
  633.         lock = newlock;
  634.     }
  635.     FreeMem(fib, sizeof(FIB));
  636.     bmov(cwd + i, cwd, 256 - i);
  637.     if (str)
  638.         Oputs(cwd);
  639.     goto cdset;
  640.     }
  641.     str = next_word(str);
  642.     if (*str == '\0')
  643.     Oputs(cwd);
  644.     str[strlen(str)+1] = '\0';          /* add second \0 on end */
  645.     while (*str) {
  646.     for (ptr = str; *ptr && *ptr != '/' && *ptr != ':'; ++ptr);
  647.     switch (*ptr) {
  648.     case ':':
  649.         sc = ptr[1];
  650.         ptr[1] = '\0';
  651.         if (attempt_cd(str))
  652.         strcpy(cwd, str);
  653.         ptr[1] = sc;
  654.         break;
  655.     case '\0':
  656.     case '/':
  657.         *ptr = '\0';
  658.         if (strcmp(str, "..") == 0 || str == ptr)
  659.         str = "/";
  660.         if (*str && attempt_cd(str)) {
  661.         if (*str == '/') {
  662.             rmlast(cwd);
  663.         } else {
  664.             if (cwd[0] == 0 || cwd[strlen(cwd)-1] != ':')
  665.             strcat(cwd, "/");
  666.             strcat(cwd, str);
  667.         }
  668.         }
  669.         break;
  670.     }
  671.     str = ptr + 1;
  672.     }
  673. cdset:
  674.     set_var(LEVEL_SET, V_CWD, cwd);
  675.     return (0);
  676. }
  677.  
  678. attempt_cd(str)
  679. char *str;
  680. {
  681.     register struct FileLock *oldlock, *filelock;
  682.  
  683.     if (filelock = Lock(str, ACCESS_READ)) {
  684.     if (isdir(str)) {
  685.         UnLock(CurrentDir(filelock));
  686.         Clock = filelock;
  687.         return(1);
  688.     }
  689.     UnLock(filelock);
  690.     ierror(str, 212);
  691.     } else {
  692.     ierror(str, 205);
  693.     }
  694.     return (0);
  695. }
  696.  
  697.  
  698. /*
  699.  * remove last component. Start at end and work backwards until reach
  700.  * a '/'
  701.  */
  702.  
  703. rmlast(str)
  704. char *str;
  705. {
  706.     register char *ptr = str + strlen(str) - 1;
  707.  
  708.     while (ptr != str && *ptr != '/' && *ptr != ':')
  709.     --ptr;
  710.     if (*ptr != ':')
  711.     ptr[0] = '\0';
  712.     else
  713.     ptr[1] = '\0';
  714. }
  715.  
  716.  
  717. do_mkdir()
  718. {
  719.     register short i;
  720.     register struct FileLock *lock;
  721.  
  722.     for (i = 1; i < ac; ++i) {
  723.     if (lock = CreateDir (av[i])) {
  724.         UnLock (lock);
  725.         continue;
  726.     }
  727.     perror (av[i]);
  728.     }
  729.     return (0);
  730. }
  731.  
  732. /*
  733.  *  MV file1 file2
  734.  *  MV file1 file2....fileN dir
  735.  */
  736.  
  737. do_mv()
  738. {
  739.     char dest[256];
  740.     register short i, len;
  741.     register char *str;
  742.  
  743.     --ac;
  744.     if (isdir(av[ac])) {
  745.     len = strlen(av[ac]);
  746.     for (i = 1; i < ac; ++i) {
  747.         str = av[i] + strlen(av[i]) - 1;
  748.         while (str >= av[i] && *str != '/' && *str != ':')
  749.         --str;
  750.         ++str;
  751.         if (*str == 0) {
  752.         ierror(av[i], 508);
  753.         return (-1);
  754.         }
  755.         strcpy(dest, av[ac]);
  756.         if (dest[0] && dest[len-1] != ':' && dest[len-1] != '/')
  757.         strcat(dest, "/");
  758.         strcat(dest, str);
  759.         if (Rename(av[i], dest) == 0)
  760.         break;
  761.     }
  762.     if (i == ac)
  763.         return (1);
  764.     } else {
  765.     i = 1;
  766.     if (ac != 2) {
  767.         ierror("mv:", 507);
  768.         return (-1);
  769.     }
  770.     if (Rename (av[1], av[2]))
  771.         return (0);
  772.     }
  773.     perror (av[i]);
  774.     return (-1);
  775. }
  776.  
  777.  
  778. do_rm()
  779. {
  780.     register short i, recur;
  781.  
  782.     recur = (strncmp(av[1], "-r", 2)) ? 0 : 1;
  783.  
  784.     for (i = 1 + recur; i < ac; ++i) {
  785.     if (isdir(av[i]) && recur)
  786.         rmdir(av[i]);
  787.     if (!DeleteFile(av[i]))
  788.         perror(av[i]);
  789.     }
  790.     return (0);
  791. }
  792.  
  793. rmdir(name)
  794. char *name;
  795. {
  796.     register LOCK *lock, *cwd;
  797.     register FIB *fib;
  798.     register char *buf;
  799.  
  800.     buf = (char *)AllocMem(256, 0);
  801.     fib = (FIB *)AllocMem(sizeof(FIB), 0);
  802.  
  803.     if (lock = Lock(name, ACCESS_READ)) {
  804.     cwd = CurrentDir(lock);
  805.     if (Examine(lock, fib)) {
  806.         buf[0] = 0;
  807.         while (ExNext(lock, fib)) {
  808.         if (isdir(fib->fib_FileName))
  809.             rmdir(fib->fib_FileName);
  810.         if (buf[0]) {
  811.             if (!DeleteFile(buf))
  812.             perror(buf);
  813.         }
  814.         strcpy(buf, fib->fib_FileName);
  815.         }
  816.         if (buf[0]) {
  817.         if (!DeleteFile(buf))
  818.             perror(buf);
  819.         }
  820.     }
  821.     UnLock(CurrentDir(cwd));
  822.     } else {
  823.     perror(name);
  824.     }
  825.     FreeMem(fib, sizeof(FIB));
  826.     FreeMem(buf, 256);
  827. }
  828.  
  829.  
  830. do_history()
  831. {
  832.     register struct HIST *hist;
  833.     register short i = H_tail_base;
  834.     register short len = (av[1]) ? strlen(av[1]) : 0;
  835.  
  836.     for (hist = H_tail; hist; hist = hist->prev) {
  837.     if (len == 0 || strncmp(av[1], hist->line, len) == 0) {
  838.         fhprintf (Cout, "%3ld ", i);
  839.         Oputs (hist->line);
  840.     }
  841.     ++i;
  842.     if (CHECKBREAK())
  843.         break;
  844.     }
  845.     return (0);
  846. }
  847.  
  848.  
  849. do_mem()
  850. {
  851.     register long cfree, ffree;
  852.     extern long AvailMem();
  853.  
  854.     Forbid();
  855.     cfree = AvailMem (MEMF_CHIP);
  856.     ffree = AvailMem (MEMF_FAST);
  857.     Permit();
  858.  
  859.     if (ffree)
  860.     fhprintf (Cout, "FAST memory:%10ld\n", ffree);
  861.     fhprintf (Cout, "CHIP memory:%10ld\n", cfree);
  862.     fhprintf (Cout, "Total -----:%5ld K\n", (ffree + cfree) >> 10);
  863.     return (0);
  864. }
  865.  
  866. /*
  867.  * foreach var_name  ( str str str str... str ) commands
  868.  * spacing is important (unfortunetly)
  869.  *
  870.  * ac=0    1 2 3 4 5 6 7
  871.  * foreach i ( a b c ) echo $i
  872.  * foreach i ( *.c )   "echo -n "file ->";echo $i"
  873.  */
  874.  
  875. do_foreach()
  876. {
  877.     register short i, cstart, cend, old;
  878.     register char *cstr, *vname, *ptr, *scr, *args;
  879.  
  880.     cstart = i = (*av[2] == '(') ? 3 : 2;
  881.     while (i < ac) {
  882.     if (*av[i] == ')')
  883.         break;
  884.     ++i;
  885.     }
  886.     if (i == ac) {
  887.     Eputs ("')' expected");
  888.     return (-1);
  889.     }
  890.     ++H_stack;
  891.     cend = i;
  892.     vname = strcpy(malloc(strlen(av[1])+1), av[1]);
  893.     cstr = compile_av (av, cend + 1, ac);
  894.     ptr = args = compile_av (av, cstart, cend);
  895.     while (*ptr) {
  896.     while (*ptr == ' ' || *ptr == 9)
  897.         ++ptr;
  898.     scr = ptr;
  899.     if (*scr == '\0')
  900.         break;
  901.     while (*ptr && *ptr != ' ' && *ptr != 9)
  902.         ++ptr;
  903.     old = *ptr;
  904.     *ptr = '\0';
  905.     set_var (LEVEL_SET, vname, scr);
  906.     if (CHECKBREAK())
  907.         break;
  908.     exec_command (cstr);
  909.     *ptr = old;
  910.     }
  911.     --H_stack;
  912.     free (args);
  913.     free (cstr);
  914.     unset_var (LEVEL_SET, vname);
  915.     free (vname);
  916.     return (0);
  917. }
  918.  
  919.  
  920. do_forever(str)
  921. register char *str;
  922. {
  923.     long rcode = 0;
  924.     register char *ptr = next_word(str);
  925.  
  926.     ++H_stack;
  927.     for (;;) {
  928.     if (CHECKBREAK()) {
  929.         rcode = 20;
  930.         break;
  931.     }
  932.     if (exec_command (ptr) < 0) {
  933.         str = get_var(LEVEL_SET, V_LASTERR);
  934.         rcode = (str) ? atoi(str) : 20;
  935.         break;
  936.     }
  937.     }
  938.     --H_stack;
  939.     return (rcode);
  940. }
  941.  
  942.  
  943. \Rogue\Monster\
  944. else
  945.   echo "will not over write comm1.c"
  946. fi
  947. if [ `wc -c comm1.c | awk '{printf $1}'` -ne 12245 ]
  948. then
  949. echo `wc -c comm1.c | awk '{print "Got " $1 ", Expected " 12245}'`
  950. fi
  951. if `test ! -s comm2.c`
  952. then
  953. echo "writing comm2.c"
  954. cat > comm2.c << '\Rogue\Monster\'
  955.  
  956. /*
  957.  * COMM2.C
  958.  *
  959.  *
  960.  * (c)1986 Matthew Dillon     Feb 1987
  961.  *
  962.  *    ABORTLINE
  963.  *    RETURN
  964.  *    STRHEAD
  965.  *    STRTAIL
  966.  *    IF
  967.  *    LABEL
  968.  *    GOTO
  969.  *    INC
  970.  *    INPUT
  971.  *    VER
  972.  *    CP
  973.  *    SHELLSTAT
  974.  *    SETENV
  975.  *    UNSETENV
  976.  *    IPC
  977.  *    CLDRES
  978.  *
  979.  */
  980.  
  981. #include "shell.h"
  982. #include <libraries/dos.h>
  983. #include <libraries/dosextens.h>
  984. #include <local/ipc.h>
  985.  
  986. typedef struct CommandLineInterface CLI;
  987.  
  988. extern LOCK *CurrentDir(), *Lock(), *CreateDir();
  989. extern IPCMSG *SendIPC();
  990.  
  991. do_cldres()
  992. {
  993.     if (DResBase)
  994.     CloseLibrary(DResBase);
  995.     DResBase = NULL;
  996. }
  997.  
  998. /*
  999.  *  do_ipc appname[.project] command
  1000.  */
  1001.  
  1002. do_ipc(command)
  1003. char *command;
  1004. {
  1005.     IPCMSG *msg;
  1006.     char *str = next_word(next_word(command));
  1007.     char *ptr;
  1008.     char appname[64];
  1009.     char *cmd;
  1010.     long result;
  1011.  
  1012.     if (!DResBase)
  1013.     DResBase = (long)OpenLibrary("dres.library", 0);
  1014.     if (!DResBase) {
  1015.     puts("Unable to open dres.library");
  1016.     return(-1);
  1017.     }
  1018.     for (ptr = av[1]; *ptr && *ptr != '.'; ++ptr);
  1019.     if (*ptr == '.') {
  1020.     if (cmd = malloc(strlen(ptr+1)+strlen(str)+2)) {
  1021.         strcpy(cmd, ptr+1);
  1022.         strcpy(cmd + strlen(cmd) + 1, str);
  1023.     }
  1024.     } else {
  1025.     if (cmd = malloc(strlen(str)+2)) {
  1026.         cmd[0] = 0;
  1027.         strcpy(cmd+1, str);
  1028.     }
  1029.     }
  1030.     if (!cmd)
  1031.     return(-1);
  1032.     strcpy(appname, av[1]);
  1033.     appname[ptr - av[1]] = 0;
  1034.     strcat(appname, ".CMD");
  1035.  
  1036.     msg = SendIPC(appname, cmd, strlen(cmd)+strlen(str)+2, 0);
  1037.     free(cmd);
  1038.     if (!msg)
  1039.     return(-1);
  1040.     WaitMsg(msg);
  1041.     if (msg->RFlags & IF_ERROR) {
  1042.     if (msg->RFlags & IF_NOAPP)
  1043.         printf("Application not found");
  1044.     else
  1045.         printf("Operation Failed");
  1046.     if (msg->RBuf)
  1047.         printf(": %s\n", msg->RBuf);
  1048.     puts("");
  1049.     if (!msg->Error)
  1050.         msg->Error = 20;
  1051.     } else {
  1052.     if (msg->RBuf)
  1053.         Oputs(msg->RBuf);
  1054.     }
  1055.     result = msg->Error;
  1056.     FreeIPC(msg);
  1057.     return(result);
  1058. }
  1059.  
  1060. do_abortline()
  1061. {
  1062.     Exec_abortline = 1;
  1063.     return (0);
  1064. }
  1065.  
  1066. do_return()
  1067. {
  1068.     Exec_abortline = 1;
  1069.     if (Src_stack) {
  1070.     fseek (Src_base[Src_stack - 1], 0, 2);
  1071.     return ((ac < 2) ? 0 : atoi(av[1]));
  1072.     } else {
  1073.     main_exit ((ac < 2) ? 0 : atoi(av[1]));
  1074.     }
  1075. }
  1076.  
  1077. /*
  1078.  * STRHEAD
  1079.  *
  1080.  * place a string into a variable removing everything after and including
  1081.  * the 'break' character or until a space is found in the string.
  1082.  *
  1083.  * strhead varname breakchar string
  1084.  *
  1085.  */
  1086.  
  1087. do_strhead()
  1088. {
  1089.     register char *str = av[3];
  1090.     register char bc = *av[2];
  1091.  
  1092.     while (*str && *str != bc)
  1093.     ++str;
  1094.     *str = '\0';
  1095.     set_var (LEVEL_SET, av[1], av[3]);
  1096.     return (0);
  1097. }
  1098.  
  1099. do_strtail()
  1100. {
  1101.     register char *str = av[3];
  1102.     register char bc = *av[2];
  1103.  
  1104.     while (*str && *str != bc)
  1105.     ++str;
  1106.     if (*str)
  1107.     ++str;
  1108.     set_var (LEVEL_SET, av[1], str);
  1109.     return (0);
  1110. }
  1111.  
  1112. /*
  1113.  * if A < B   <, >, =, <=, >=, !=, where A and B are either:
  1114.  * nothing
  1115.  * a string
  1116.  * a value (begins w/ number)
  1117.  *
  1118.  *  if -[!]f file
  1119.  *
  1120.  */
  1121.  
  1122. do_if(garbage, com)
  1123. char *garbage;
  1124. {
  1125.     register char *v1, *v2, *v3, result, num;
  1126.     register int n1, n2;
  1127.  
  1128.     switch (com) {
  1129.     case 0:
  1130.     if (If_stack && If_base[If_stack - 1]) {
  1131.         if (If_stack == MAXIF) {
  1132.         ierror(NULL, 510);
  1133.         } else {
  1134.         If_base[If_stack++] = 1;
  1135.         }
  1136.         break;
  1137.     }
  1138.     result = num = 0;
  1139.     v1 = av[1];
  1140.     switch(ac) {
  1141.     case 2:          /* if $var; */
  1142.         if (v1[0] == 0 || (v1[1] == 0 && v1[0] == ' '))
  1143.         goto do_result;
  1144.         result = 1;      /* fall through    */
  1145.     case 1:          /* if        */
  1146.         goto do_result;
  1147.     case 3:          /* if -flag name    */
  1148.         if (*v1 == '-')
  1149.         ++v1;
  1150.         if (*v1 == '!') {
  1151.         ++v1;
  1152.         result = 1 - result;
  1153.         }
  1154.         switch(*v1) {
  1155.         case 'f':
  1156.         {
  1157.             LOCK *lock;
  1158.             mountrequest(0);
  1159.             if (lock = Lock(av[2], SHARED_LOCK)) {
  1160.             result = 1 - result;
  1161.             UnLock(lock);
  1162.             }
  1163.             mountrequest(1);
  1164.         }
  1165.         break;
  1166.         default:
  1167.         goto splug;
  1168.         }
  1169.         goto do_result;
  1170.     case 4:
  1171.         goto cond;
  1172.     }
  1173. splug:
  1174.     ierror(NULL, 500);
  1175.     goto do_result;
  1176. cond:
  1177.     v1 = av[1]; v2 = av[2]; v3 = av[3];
  1178.     while (*v1 == ' ')
  1179.         ++v1;
  1180.     while (*v2 == ' ')
  1181.         ++v2;
  1182.     while (*v3 == ' ')
  1183.         ++v3;
  1184.     if (*v1 >= '0' && *v1 <= '9') {
  1185.         num = 1;
  1186.         n1 = atoi(v1);
  1187.         n2 = atoi(v3);
  1188.     }
  1189.     while (*v2) {
  1190.         switch (*v2++) {
  1191.         case '>':
  1192.         result |= (num) ? (n1 >  n2) : (strcmp(v1, v3) > 0);
  1193.         break;
  1194.         case '<':
  1195.         result |= (num) ? (n1 <  n2) : (strcmp(v1, v3) < 0);
  1196.         break;
  1197.         case '=':
  1198.         result |= (num) ? (n1 == n2) : (strcmp(v1, v3) ==0);
  1199.         break;
  1200.         default:
  1201.         ierror (NULL, 503);
  1202.         break;
  1203.         }
  1204.     }
  1205. do_result:
  1206.     if (If_stack == MAXIF)
  1207.         ierror(NULL,510);
  1208.     else
  1209.         If_base[If_stack++] = !result;
  1210.     break;
  1211.     case 1:
  1212.     if (If_stack > 1 && If_base[If_stack - 2])
  1213.         break;
  1214.     if (If_stack)
  1215.         If_base[If_stack - 1] ^= 1;
  1216.     break;
  1217.     case 2:
  1218.     if (If_stack)
  1219.         --If_stack;
  1220.     break;
  1221.     }
  1222.     SDisable = (If_stack) ? If_base[If_stack - 1] : 0;
  1223.     return (0);
  1224. }
  1225.  
  1226. do_label()
  1227. {
  1228.     char aseek[32];
  1229.  
  1230.     if (Src_stack == 0) {
  1231.     ierror (NULL, 502);
  1232.     return (-1);
  1233.     }
  1234.     sprintf (aseek, "%ld %ld", Src_pos[Src_stack-1], If_stack);
  1235.     set_var (LEVEL_LABEL + Src_stack - 1, av[1], aseek);
  1236.     return (0);
  1237. }
  1238.  
  1239. do_goto()
  1240. {
  1241.     register long new;
  1242.     register long pos;
  1243.     register char *lab;
  1244.  
  1245.     if (Src_stack == 0) {
  1246.     ierror (NULL, 502);
  1247.     } else {
  1248.     lab = get_var (LEVEL_LABEL + Src_stack - 1, av[1]);
  1249.     if (lab == NULL) {
  1250.         ierror (NULL, 501);
  1251.     } else {
  1252.         pos = atoi(lab);
  1253.         fseek (Src_base[Src_stack - 1], pos, 0);
  1254.         Src_pos[Src_stack - 1] = pos;
  1255.         new = atoi(next_word(lab));
  1256.         if (new > MAXIF)
  1257.         new = MAXIF;
  1258.         for (; If_stack < new; ++If_stack)
  1259.         If_base[If_stack] = 0;
  1260.         If_stack = new;
  1261.     }
  1262.     }
  1263.     Exec_abortline = 1;
  1264.     return (0);      /* Don't execute rest of this line */
  1265. }
  1266.  
  1267.  
  1268. do_inc(garbage, com)
  1269. char *garbage;
  1270. {
  1271.     register char *var;
  1272.     char num[32];
  1273.  
  1274.     if (ac == 3)
  1275.     com = atoi(av[2]);
  1276.     var = get_var (LEVEL_SET, av[1]);
  1277.     if (var) {
  1278.     sprintf (num, "%ld", atoi(var)+com);
  1279.     set_var (LEVEL_SET, av[1], num);
  1280.     }
  1281.     return (0);
  1282. }
  1283.  
  1284. do_input()
  1285. {
  1286.     char in[256];
  1287.  
  1288.     if (Ogets(in))
  1289.     set_var (LEVEL_SET, av[1], in);
  1290.     return (0);
  1291. }
  1292.  
  1293. do_ver()
  1294. {
  1295.     Oputs (VERSION);
  1296.     return (0);
  1297. }
  1298.  
  1299.  
  1300. /*
  1301.  * CP file            (to current directory)
  1302.  * CP [-r] dir            (to current directory)
  1303.  * CP file file
  1304.  * CP file file file... destdir
  1305.  * CP [-r] dir dir dir... destdir
  1306.  */
  1307.  
  1308. do_cp()
  1309. {
  1310.     register short recur, i, ierr;
  1311.     register char *destname;
  1312.     register char destisdir;
  1313.     register FIB *fib;
  1314.     char copysilent = (get_var(LEVEL_SET, V_COPYSILENT) != NULL);
  1315.  
  1316.     if (get_var(LEVEL_SET, V_COPYDATE) != NULL)
  1317.     copysilent |= 2;
  1318.  
  1319.     ierr = 0;
  1320.     fib = (FIB *)AllocMem(sizeof(FIB), 0);
  1321.     recur = (strncmp(av[1], "-r", 2)) ? 0 : 1;
  1322.     destname = av[ac - 1];
  1323.  
  1324.     if (ac < recur + 3) {
  1325.     ++ac;
  1326.     destname = "";
  1327.     }
  1328.     /*
  1329.      *    ierr = 500;
  1330.      *    goto done;
  1331.      */
  1332.  
  1333.     destisdir = isdir(destname);
  1334.     if (ac > recur + 3 && !destisdir) {
  1335.     ierr = 507;
  1336.     goto done;
  1337.     }
  1338.  
  1339.     /*
  1340.      * copy set:            reduce to:
  1341.      *      file to file               file to file
  1342.      *      dir  to file (NOT ALLOWED)
  1343.      *      file to dir               dir to dir
  1344.      *      dir  to dir               dir to dir
  1345.      *
  1346.      */
  1347.  
  1348.  
  1349.     for (i = recur + 1; i < ac - 1; ++i) {
  1350.     short srcisdir = isdir(av[i]);
  1351.     if (srcisdir) {
  1352.         struct FileLock *srcdir, *destdir;
  1353.         if (!destisdir) {        /* disallow dir to file */
  1354.         ierr = 507;
  1355.         goto done;
  1356.         }
  1357.         if (!(destdir = Lock(destname, ACCESS_READ))) {
  1358.         ierr = 205;
  1359.         goto done;
  1360.         }
  1361.         if (!(srcdir = Lock(av[i], ACCESS_READ))) {
  1362.         ierr = 205;
  1363.         UnLock(destdir);
  1364.         goto done;
  1365.         }
  1366.         ierr = copydir(srcdir, destdir, recur, copysilent, 1);
  1367.         UnLock(srcdir);
  1368.         UnLock(destdir);
  1369.         if (ierr)
  1370.         break;
  1371.     } else {              /* FILE to DIR,    FILE to FILE   */
  1372.         struct FileLock *destdir, *srcdir, *tmp;
  1373.         char *destfilename;
  1374.  
  1375.         srcdir = (struct FileLock *)((PROC *)FindTask(NULL))->pr_CurrentDir;
  1376.         if (destisdir) {
  1377.         if ((tmp = Lock(av[i], ACCESS_READ)) == NULL || !Examine(tmp,fib)){
  1378.             if (tmp)
  1379.             UnLock(tmp);
  1380.             ierr = 205;
  1381.             goto done;
  1382.         }
  1383.         UnLock(tmp);
  1384.         destdir = Lock(destname, ACCESS_READ);
  1385.         destfilename = fib->fib_FileName;
  1386.         } else {
  1387.         destdir = srcdir;
  1388.         destfilename = destname;
  1389.         copysilent |= 1;
  1390.         }
  1391.         ierr = copyfile(av[i], srcdir, destfilename, destdir, copysilent, 0);
  1392.         if (destisdir)
  1393.         UnLock(destdir);
  1394.         if (ierr)
  1395.         break;
  1396.     }
  1397.     }
  1398. done:
  1399.     FreeMem(fib, sizeof(*fib));
  1400.     if (ierr) {
  1401.     ierror("cp", ierr);
  1402.     return(20);
  1403.     }
  1404.     return(0);
  1405. }
  1406.  
  1407.  
  1408. copydir(srcdir, destdir, recur, silent, tab)
  1409. register struct FileLock *srcdir, *destdir;
  1410. {
  1411.     LOCK *cwd;
  1412.     register FIB *srcfib;
  1413.     register LOCK *destlock, *srclock;
  1414.     DATESTAMP DS;
  1415.     int ierr;
  1416.  
  1417.     ierr = 0;
  1418.     srcfib = (FIB *)AllocMem(sizeof(FIB), 0);
  1419.     if (Examine(srcdir, srcfib)) {
  1420.     DS = srcfib->fib_Date;
  1421.     if (!(silent & 1))
  1422.         printf("%*s%s (DIR)\n", tab, "", srcfib->fib_FileName);
  1423.     while (ExNext(srcdir, srcfib)) {
  1424.         if (srcfib->fib_DirEntryType < 0) {
  1425.         ierr = copyfile(srcfib->fib_FileName,srcdir,srcfib->fib_FileName,destdir,silent,tab+4);
  1426.         if (ierr)
  1427.             break;
  1428.         } else {
  1429.         if (recur) {
  1430.             cwd = CurrentDir(srcdir);
  1431.             if (srclock = Lock(srcfib->fib_FileName, ACCESS_READ)) {
  1432.             CurrentDir(destdir);
  1433.             if (!(destlock = Lock(srcfib->fib_FileName, ACCESS_READ))) {
  1434.                 if (destlock = CreateDir(srcfib->fib_FileName)) {
  1435.                 UnLock(destlock);
  1436.                 if (silent & 2) {
  1437.                     setfiledate(srcfib->fib_FileName, &DS);
  1438.                     if (srcfib->fib_Comment[0])
  1439.                     SetComment(srcfib->fib_FileName, srcfib->fib_Comment);
  1440.                 }
  1441.                 destlock = Lock(srcfib->fib_FileName, ACCESS_READ);
  1442.                 }
  1443.             }
  1444.             if (destlock) {
  1445.                 ierr = copydir(srclock, destlock, recur, silent, tab+4);
  1446.                 UnLock(destlock);
  1447.             } else {
  1448.                 ierr = IoErr();
  1449.             }
  1450.             UnLock(srclock);
  1451.             } else {
  1452.             ierr = IoErr();
  1453.             }
  1454.             CurrentDir(cwd);
  1455.             if (ierr)
  1456.             break;
  1457.         }
  1458.         }
  1459.     }
  1460.     } else {
  1461.     ierr = IoErr();
  1462.     }
  1463.     FreeMem(srcfib, sizeof(FIB));
  1464.     return(ierr);
  1465. }
  1466.  
  1467.  
  1468. copyfile(srcname, srcdir, destname, destdir, silent, tab)
  1469. char *srcname, *destname;
  1470. struct FileLock *srcdir, *destdir;
  1471. {
  1472.     LOCK *cwd;
  1473.     DATESTAMP DS;
  1474.     int i, ierr;
  1475.     char *buf;
  1476.     char *com = NULL;
  1477.     long  buflen;
  1478.     long  fhs, fhd;
  1479.  
  1480.     if (!(silent&1))
  1481.     printf("%*s%s\n", tab, "", srcname);
  1482.     for (buflen = 65536; buflen; buflen >>= 1) {
  1483.     if (buf = AllocMem(buflen, MEMF_PUBLIC))
  1484.         break;
  1485.     }
  1486.     if (buf == NULL)
  1487.     return(103);    /* ERROR_NO_FREE_STORE      */
  1488.     ierr = 0;
  1489.     cwd = (LOCK *)CurrentDir(srcdir);
  1490.  
  1491.     if (silent & 2) {
  1492.     register FIB *fib = (FIB *)AllocMem(sizeof(FIB), MEMF_PUBLIC);
  1493.     register LOCK *lock = Lock(srcname, ACCESS_READ);
  1494.     if (lock && fib && Examine(lock, fib)) {
  1495.         if (fib->fib_Comment[0]) {
  1496.         com = malloc(strlen(fib->fib_Comment)+1);
  1497.         strcpy(com, fib->fib_Comment);
  1498.         }
  1499.         DS = fib->fib_Date;
  1500.     } else {
  1501.         silent &= ~2;
  1502.     }
  1503.     if (lock)
  1504.         UnLock(lock);
  1505.     if (fib)
  1506.         FreeMem(fib, sizeof(FIB));
  1507.     }
  1508.     fhs = Open(srcname, 1005);
  1509.     if (fhs == NULL) {
  1510.     ierr = 205;
  1511.     goto fail;
  1512.     }
  1513.     CurrentDir(destdir);
  1514.     fhd = Open(destname, 1006);
  1515.     if (fhd == NULL) {
  1516.     ierr = IoErr();
  1517.     Close(fhs);
  1518.     goto fail;
  1519.     }
  1520.     while ((i = Read(fhs, buf, buflen)) > 0) {
  1521.     if (CHECKBREAK()) {
  1522.         ierr = 509;
  1523.         break;
  1524.     }
  1525.     if (Write(fhd, buf, i) != i) {
  1526.         ierr = IoErr();
  1527.         break;
  1528.     }
  1529.     if (CHECKBREAK()) {
  1530.         ierr = 509;
  1531.         break;
  1532.     }
  1533.     }
  1534.     if (i < 0)
  1535.     ierr = IoErr();
  1536.     Close(fhd);
  1537.     Close(fhs);
  1538.     if (!ierr && (silent & 2)) {
  1539.     setfiledate(destname, &DS);
  1540.     if (com)
  1541.         SetComment(destname, com);
  1542.     }
  1543. fail:
  1544.     if (com)
  1545.     free(com);
  1546.     FreeMem(buf, buflen);
  1547.     CurrentDir(cwd);
  1548.     return(ierr);
  1549. }
  1550.  
  1551. do_shellstat()
  1552. {
  1553.     {
  1554.     register short i = 0;
  1555.     register unsigned long mask = ((TASK *)FindTask(NULL))->tc_SigAlloc;
  1556.     printf("Signals: %08lx  ", mask);
  1557.     while (mask) {
  1558.         if (mask & 1)
  1559.         ++i;
  1560.         mask >>= 1;
  1561.     }
  1562.     printf("(%ld)\n", i);
  1563.     }
  1564.     /*
  1565.     {
  1566.     register PROC *proc = (PROC *)FindTask(NULL);
  1567.     register CLI  *cli = (CLI *)((long)proc->pr_CLI << 2);
  1568.     if (proc) {
  1569.         long stack;
  1570.         printf("pr_TaskNum: %ld\n", proc->pr_TaskNum);
  1571.         printf("pr_CIS: %08lx\n", proc->pr_CIS);
  1572.         printf("pr_COS: %08lx\n", proc->pr_COS);
  1573.         printf("cli_standardinput : %08lx\n", cli->cli_StandardInput);
  1574.         printf("cli_standardoutput: %08lx\n", cli->cli_StandardOutput);
  1575.         printf("cli_currentinput  : %08lx\n", cli->cli_CurrentInput);
  1576.         printf("cli_currentoutput : %08lx\n", cli->cli_CurrentOutput);
  1577.         printf("cli_Module        : %08lx\n", cli->cli_Module);
  1578.         printf("STACK:  %ld bytes, %08lx %08lx %08lx (%ld Free)\n",
  1579.         cli->cli_DefaultStack*4,
  1580.         proc->pr_ReturnAddr - cli->cli_DefaultStack*4, &stack, proc->pr_ReturnAddr,
  1581.         (long)&stack - (long)proc->pr_ReturnAddr + cli->cli_DefaultStack*4
  1582.         );
  1583.     }
  1584.     }
  1585.     */
  1586.     return(0);
  1587. }
  1588.  
  1589. do_printenv()
  1590. {
  1591.     register long lock;
  1592.     register FIB *fib = (FIB *)malloc(sizeof(FIB));
  1593.     register short i;
  1594.     char buf[256];
  1595.     long fh;
  1596.  
  1597.     if (lock = (long)Lock("ENV:", SHARED_LOCK)) {
  1598.     if (Examine(lock, fib)) {
  1599.         while (ExNext(lock, fib)) {
  1600.         sprintf(buf, "%-10s ", fib->fib_FileName);
  1601.         Write(Cout, buf, strlen(buf));
  1602.         sprintf(buf, "ENV:%s", fib->fib_FileName);
  1603.         if (fh = Open(buf, 1005)) {
  1604.             while ((i = Read(fh, buf, sizeof(buf))) > 0) {
  1605.             Write(Cout, buf, i);
  1606.             }
  1607.             Close(fh);
  1608.             Oputs("");
  1609.         } else {
  1610.             Oputs("<unable to open>");
  1611.         }
  1612.         }
  1613.     }
  1614.     UnLock(lock);
  1615.     }
  1616.     free(fib);
  1617.     return(0);
  1618. }
  1619.  
  1620.  
  1621.  
  1622. do_setenv(command)
  1623. char *command;
  1624. {
  1625.     long fh;
  1626.     char buf[256];
  1627.     short ierr = 0;
  1628.  
  1629.     if (ac <= 2)
  1630.     return(0);
  1631.     strcpy(buf, "ENV:");
  1632.     strcat(buf, av[1]);
  1633.     if (fh = Open(buf, 1006)) {
  1634.     register char *str = next_word(next_word(command));
  1635.     Write(fh, str, strlen(str));
  1636.     Close(fh);
  1637.     } else {
  1638.     ierr = IoErr();
  1639.     }
  1640.     return(ierr);
  1641. }
  1642.  
  1643. do_unsetenv()
  1644. {
  1645.     char buf[256];
  1646.     short i;
  1647.  
  1648.     for (i = 1; i < ac; ++i) {
  1649.     strcpy(buf, "ENV:");
  1650.     strcat(buf, av[i]);
  1651.     DeleteFile(buf);
  1652.     }
  1653.     return(0);
  1654. }
  1655.  
  1656. \Rogue\Monster\
  1657. else
  1658.   echo "will not over write comm2.c"
  1659. fi
  1660. if [ `wc -c comm2.c | awk '{printf $1}'` -ne 13801 ]
  1661. then
  1662. echo `wc -c comm2.c | awk '{print "Got " $1 ", Expected " 13801}'`
  1663. fi
  1664. echo "Finished archive 2 of 2"
  1665. # if you want to concatenate archives, remove anything after this line
  1666. exit
  1667. -- 
  1668. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  1669. Have five nice days.
  1670.